home *** CD-ROM | disk | FTP | other *** search
/ A.C.E. 2 / ACE CD 2.iso / FILES / UTILS / GAMESDS2.DMS / in.adf / GDS_Tutorial.lha / Tutorial / battle.c next >
Encoding:
C/C++ Source or Header  |  1994-11-15  |  51.2 KB  |  1,422 lines
  1. /****************************************************************************
  2.  
  3. Note: This demo calls GameSmith functions via registerized parameters.  If
  4. your 'C' compiler does not support the passing of parameters in CPU registers,
  5. then you will need to delete the "_" (underscore) character in front of all
  6. GameSmith calls before compiling.
  7.  
  8. This demo was written with SAS/C version 6.3 by John Enright, and is hereby
  9. placed in the public domain. :)  Do with it what you will, as long as no
  10. profit is gained by any persons.  This demo and the accompanying tutorial
  11. are included with the GameSmith Development System by Bithead Technologies.
  12.  
  13. Contact Oregon Research for information about obtaining a copy of GDS.
  14.  
  15. ****************************************************************************/
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <exec/memory.h>
  21. #include <exec/types.h>
  22. #include <graphics/gfx.h>
  23. #include <graphics/gfxbase.h>
  24.  
  25. #include <proto/exec.h>
  26. #include <proto/dos.h>
  27. #include <proto/graphics.h>
  28. #include <proto/intuition.h>
  29.  
  30. #include "GameSmith:GameSmith.h"
  31. #include "GameSmith:include/proto/all_regargs.h"
  32. #include "GameSmith:include/libraries/libptrs.h"
  33.  
  34. #include "gfx/tank_blue.h"   /* need collision table defines */
  35.  
  36. #define TURN_RATE   4      /* number of vertical blanks before allowing next turn */
  37. #define PLAYERS   2        /* number of players */
  38. #define FLICKER_DELAY   (50*2)   /* invulnerable period after being shot (in seconds) */
  39.  
  40. #define MAX_SPEED   4   /* maximum bullet speed (n * tank speed) */
  41.  
  42. #define SOUNDS 5      /* five different sounds per player */
  43.  
  44. #define SHOOT  0      /* bullet shot sound */
  45. #define HIT    1      /* tank hit sound */
  46. #define MISS   2      /* bullet missed & exploded */
  47. #define BOUNCE 3      /* bullet bounced */
  48. #define MOVE   4      /* tank movement */
  49.  
  50. #define GAME_SCORE   21      /* score to reach in order to win, must win by 2 */
  51.  
  52. #define SCORE_BG     0x00000044   /* color used for score area background */
  53. #define SCORE_TEXT   0x00ff1122   /* color used for score text */
  54.  
  55. #define OPTIONS   5       /* number of options */
  56. #define OPT_TOP   50      /* Y coord for top option line */
  57. #define OPT_SPACING   25  /* number of lines between option text baselines */
  58.  
  59. #define RELOAD_DELAY  25  /* delay time before tank can reshoot */
  60.  
  61. /*-------------------------------------------------------------------------*/
  62. /* error return codes:                                                      */
  63.  
  64. #define ERR_DISPLAY       -1      /* can't open GameSmith display */
  65. #define ERR_BATTLEFIELD   -2      /* can't load battlefield pic */
  66. #define ERR_GOLDTANK      -3      /* can't load gold tank anim obj */
  67. #define ERR_BLUETANK      -4      /* can't load blue tank anim obj */
  68. #define ERR_PTR           -5      /* can't load pointer anim obj */
  69. #define ERR_BULLET        -6      /* can't load bullet anim obj */
  70. #define ERR_EXPLODE       -7      /* can't load explosion anim obj */
  71. #define ERR_ANIMLIST      -8      /* can't allocate anim display list */
  72. #define ERR_SOUNDLOAD     -9      /* can't load one or more sound samples */
  73. #define ERR_SOUNDOPEN     -10     /* can't open/allocate sound system */
  74. #define ERR_ANIMADD       -11     /* can't add object to display list */
  75. #define ERR_INTUITION     -12     /* can't open Intuition screen & window */
  76.  
  77. /*-------------------------------------------------------------------------*/
  78. /* Function Prototypes                                                      */
  79.  
  80. int setup(void);
  81. int get_sounds(void);
  82. int intui_happy(void);
  83. void error_display(int);
  84. int options(void);
  85. void draw_options(void);
  86. void draw_optptr(int);
  87. void reset(void);
  88. int fight(void);
  89. int show_scores(void);
  90. void wait_winner(int);
  91. void clear_bitmap(struct BitMap *);
  92. void copy_bitmap(struct BitMap *,struct BitMap *);
  93. __stdargs void collision(struct anim_struct *,struct anim_struct *,
  94.      struct collision_struct *,struct collision_struct *);
  95. __stdargs void collision_bg(struct anim_struct *,struct coll_bg_struct *,int);
  96. void bounce_em(struct anim_cplx *,int,int);
  97. int check_abort(void);
  98. void pause_game(void);
  99. void cleanup(void);
  100.  
  101. /*-------------------------------------------------------------------------*/
  102. /* some global variables                                                   */
  103.  
  104. unsigned long color2[2]={SCORE_BG,SCORE_TEXT};
  105. unsigned long color[64];
  106. int dlist=-1;                  /* display list handle for anims */
  107. int dlist2=-1;                 /* display list handle for anims */
  108.  
  109.          /* BAD PRACTICE ALERT! ptr to hardware keyboard reg */
  110. unsigned char *keybrd=(unsigned char *)0xbfec01;
  111.  
  112. int move_x[12]={0,1,2,2,2,1,0,-1,-2,-2,-2,-1};   /* x direction movement rate in pixels */
  113. int move_y[12]={-2,-2,-1,0,1,2,2,2,1,0,-1,-2};   /* y direction movement rate in pixels */
  114. int bmove_x[12];               /* bullet x direction movement rate in pixels */
  115. int bmove_y[12];               /* bullet y direction movement rate in pixels */
  116. int bullet_speed=MAX_SPEED;    /* bullet moves n times as fast as tanks */
  117. int bounce=1;                  /* bullet bounce option */
  118. int turn[PLAYERS]={0,0};
  119. int bdelay[PLAYERS]={0,0};
  120. int fire[PLAYERS]={0,0};
  121. int boom[PLAYERS]={0,0};
  122. int score[PLAYERS]={0,0};
  123. int bmove[PLAYERS][2];         /* movement for bullets in flight (x & y) */
  124. int bdirect[PLAYERS];          /* bullet direction (0 - 11) */
  125. int bump[PLAYERS][2];          /* indicators for tanks bumping into walls */
  126. int gotcha[PLAYERS]={0,0};     /* player has been hit */
  127. int flicker[PLAYERS]={0,0};    /* invulnerability count down after being shot */
  128. struct anim_cplx *blowup[PLAYERS]={NULL,NULL};   /* ptrs to bullets on impact */
  129.  
  130. struct BitMap *bm3=NULL;       /* ptr to spare bitmap for background restoration */
  131.  
  132. int page=0;                    /* current display page */
  133. int game_in_progress=0;        /* flag allows resume game from options screen */
  134. int multitask=1;               /* flag to allow multitasking during game play */
  135. int frame_rate;                /* vertical blank intervals per second */
  136.  
  137. struct RastPort rp1 = {0};     /* for printing player scores (page 1) */
  138. struct RastPort rp2 = {0};     /* for printing player scores (page 2) */
  139. struct RastPort rp3 = {0};     /* for printing options */
  140.  
  141. struct sound_struct shoot,explode_hit,explode_miss,bounce1,bounce2,move;
  142.  
  143. /* the following array defines the activity sounds for each player */
  144.  
  145. struct sound_struct *sound[PLAYERS][SOUNDS]={
  146.    {&shoot,&explode_hit,&explode_miss,&bounce1,&move},   /* player 1 sounds */
  147.    {&shoot,&explode_hit,&explode_miss,&bounce2,&move}    /* player 2 sounds */
  148.    };
  149.  
  150. /* the following defines on what channel the above sounds will play for each player */
  151.  
  152. int channel[PLAYERS][SOUNDS]={
  153.    {CHANNEL0,CHANNEL0,CHANNEL2,CHANNEL2,CHANNEL0},  /* sound channels for player 1 */
  154.    {CHANNEL1,CHANNEL1,CHANNEL3,CHANNEL3,CHANNEL1}   /* sound channels for player 2 */
  155.    };
  156.  
  157. /* ---- the anim object array pointers ---- */
  158.  
  159. struct anim_struct *tank[PLAYERS]={NULL,NULL};
  160. struct anim_struct *explode=NULL;
  161. struct anim_struct *ptr=NULL;
  162. struct anim_cplx *bullet=NULL;
  163.  
  164. /*-------------------------------------------------------------------------*/
  165. /* Intuition screen and window structs to keep WB safe from input.device   */
  166.  
  167. unsigned char title[]="GameSmith Tank Battle";
  168. unsigned char pause_title[]="<-- Close to Unpause Tank Battle ";
  169.  
  170. static char topaz8_text[]="topaz.font";
  171.  
  172. static struct TextAttr topaz8 =
  173.    {
  174.    topaz8_text,                  /* Addr of ASCIIZ string containing font name */
  175.    8,                            /* font YSize (height) */
  176.    FS_NORMAL,                    /* style flags */
  177.    FPF_DESIGNED|FPF_ROMFONT      /* flags */
  178.    };
  179.  
  180. struct NewScreen dummy_screen =
  181.    {
  182.    0,0,                          /* left & top edges */
  183.    320,40,1,                     /* width, height, & depth (filled) */
  184.    1,2,                          /* detail & block pens */
  185.    0,                            /* display mode */
  186.    CUSTOMSCREEN,                 /* type */
  187.    &topaz8,                      /* text attribute for font */
  188.    NULL,                         /* screen title */
  189.    NULL,                         /* ptr to gadgets */
  190.    NULL,                         /* ptr to bitmap */
  191.    };
  192.  
  193. struct NewWindow dummy_window =
  194.    {
  195.    0,0,320,40,                           /* left edge, top edge, width, height */
  196.    1,2,                                  /* detail & block pens */
  197.    0,                                    /* IDCMP flags */
  198.    SIMPLE_REFRESH|BORDERLESS|ACTIVATE|
  199.    NOCAREREFRESH|RMBTRAP,                /* window flags */
  200.    NULL,                                 /* ptr to 1st gadget */
  201.    NULL,                                 /* ptr to checkmark image */
  202.    title,                                /* window title */
  203.    0,                                    /* ptr to screen */
  204.    NULL,                                 /* ptr to bitmap to use for refresh */
  205.    0,0,0,0,                              /* min width & height, max width & height */
  206.    CUSTOMSCREEN                          /* window type */
  207.    };
  208.  
  209. struct NewWindow pause_window =
  210.    {
  211.    0,40,400,40,                          /* left edge, top edge, width, height */
  212.    1,2,                                  /* detail & block pens */
  213.    CLOSEWINDOW,                          /* IDCMP flags */
  214.    WINDOWSIZING|WINDOWDEPTH|
  215.    WINDOWCLOSE|WINDOWDRAG|NOCAREREFRESH|
  216.    SIMPLE_REFRESH|ACTIVATE,              /* window flags */
  217.    NULL,                                 /* ptr to 1st gadget */
  218.    NULL,                                 /* ptr to checkmark image */
  219.    pause_title,                          /* window title */
  220.    0,                                    /* ptr to screen */
  221.    NULL,                                 /* ptr to bitmap to use for refresh */
  222.    0,0,400,40,                           /* min width & height, max width & height */
  223.    WBENCHSCREEN                          /* window type */
  224.    };
  225.  
  226. struct Screen *screen=NULL;
  227. struct Window *window=NULL;
  228. struct TextFont *font=NULL;
  229.  
  230. /*-------------------------------------------------------------------------*/
  231.  
  232. struct loadILBM_struct loadpic =
  233.    {
  234.    "gfx/battlefield.pic",   /* ptr to picture name string */
  235.    NULL,               /* ptr to 1st bitmap */
  236.    NULL,               /* ptr to 2nd bitmap (if any) */
  237.    color,              /* ptr to color table array */
  238.    64,                 /* # colors in color table */
  239.    NULL,               /* height of image in pixels (filled by load call) */
  240.    NULL,               /* width of image in pixels (filled) */
  241.    NULL,               /* x display offset (filled) */
  242.    NULL,               /* y display offset (filled) */
  243.    NULL,               /* pic mode (filled) */
  244.    0,                  /* x load offset (from left) in bytes */
  245.    0,                  /* y load offset (from top) in rows */
  246.    ILBM_COLOR,         /* flags (fill color table) */
  247.    0xff,               /* bitplane fill mask */
  248.    0xff,               /* bitplane load mask */
  249.    NULL                /* address of BitMapHeader to fill */
  250.    };
  251.  
  252. struct gs_viewport vp2 =
  253.    {
  254.    NULL,                          /* ptr to next viewport */
  255.    color2,                        /* ptr to color table */
  256.    2,                             /* number of colors in table */
  257.    NULL,                          /* ptr to user copper list */
  258.    18,320,1,18,320,               /* height, width, depth, bmheight, bmwidth */
  259.    238,0,                         /* top & left viewport offsets */
  260.    0,0,                           /* X & Y bitmap offsets */
  261.    GSVP_ALLOCBM,                  /* flags (allocate bitmaps) */
  262.    NULL,NULL,                     /* 2.xx & above compatibility stuff */
  263.    NULL,NULL,                     /* bitmap pointers */
  264.    NULL,                          /* future expansion */
  265.    0,0,0,0                        /* display clip (MinX,MinY,MaxX,MaxY) */
  266.    };
  267.  
  268. struct gs_viewport vp =
  269.    {
  270.    &vp2,                          /* ptr to next viewport */
  271.    color,                         /* ptr to color table */
  272.    64,                            /* number of colors in table */
  273.    NULL,                          /* ptr to user copper list */
  274.    236,320,6,236,320+8,           /* height, width, depth, bmheight, bmwidth */
  275.    0,0,                           /* top & left viewport offsets */
  276.    0,0,                           /* X & Y bitmap offsets */
  277.    GSVP_ALLOCBM,                  /* flags (allocate bitmaps) */
  278.    NULL,NULL,                     /* 2.xx & above compatibility stuff */
  279.    NULL,NULL,                     /* bitmap pointers */
  280.    NULL,                          /* future expansion */
  281.    0,0,0,0                        /* display clip (MinX,MinY,MaxX,MaxY) */
  282.    };
  283.  
  284. struct display_struct display =
  285.    {
  286.    NULL,                          /* ptr to previous display view */
  287.    NULL,NULL,                     /* 2.xx & above compatibility stuff */
  288.    0,0,                           /* X and Y display offsets (1.3 style) */
  289.    EXTRAHALFBRITE_KEY,            /* display mode ID */
  290.    4,4,                           /* sprite priorities */
  291.    GSV_DOUBLE|GSV_BRDRBLNK,       /* flags (double buffered & blanked borders) */
  292.    &vp,                           /* ptr to 1st viewport */
  293.    NULL                           /* future expansion */
  294.    };
  295.  
  296. /***************************************************************************/
  297.  
  298. main(argc,argv)
  299. int argc;
  300. char *argv[];
  301.  
  302. {
  303.    int err,end,winner;
  304.  
  305.    if (gs_open_libs(DOS|GRAPHICS|INTUITION,0))   /* open AmigaDOS libs, latest versions */
  306.       exit(01);                /* if can't open libs, abort */
  307.    if (err=setup())            /* if couldn't get set up... abort program */
  308.       {
  309.       error_display(err);      /* tell user why we're aborting */
  310.       gs_close_libs();         /* close all libraries */
  311.       exit(02);
  312.       }
  313.    end=options();              /* show game options */
  314.    while (!end)
  315.       {
  316.       if (check_abort())       /* if user hits the Esc key */
  317.          end=options();        /* bring up the options screen */
  318.       else if (winner=fight()) /* game control */
  319.          {
  320.          wait_winner(winner-1);
  321.          end=options();
  322.          }
  323.       }
  324.    cleanup();                  /* close & deallocate everything */
  325.    gs_close_libs();            /* close all libraries */
  326.    return(0);                  /* all went well */
  327. }
  328.  
  329. /***************************************************************************/
  330. /*
  331.    This function creates the display, loads the background picture, loads
  332.    all anim objects, allocates two display lists for the animation system,
  333.    adds all objects to the appropriate lists, and shows the display.
  334. */
  335.  
  336. int setup()
  337.  
  338. {
  339.    int cnt;
  340.    struct anim_load_struct load;
  341.  
  342.    gs_get_ILBM_bm(&loadpic);         /* load color table from picture file */
  343.    #ifdef PAL_MONITOR_ID
  344.       if (GfxBase->LibNode.lib_Version >= 36)   /* if WB 2.0 or higher */
  345.          {                           /* select display mode.  Try for PAL */
  346.          if (ModeNotAvailable(PAL_MONITOR_ID))
  347.             {   /* if not PAL, use NTSC & drop vertical resolution */
  348.             display.modes |= NTSC_MONITOR_ID;
  349.             vp.height = 180;
  350.             vp.bmheight = 180;
  351.             vp2.top = 182;
  352.             frame_rate=60;          /* display refresh rate */
  353.             dummy_screen.Height=180;
  354.             }
  355.          else
  356.             {
  357.             display.modes |= PAL_MONITOR_ID;
  358.             frame_rate=50;          /* display refresh rate */
  359.             }
  360.          }
  361.    #endif
  362.    if (gs_create_display(&display)) /* create the GameSmith display */
  363.       {
  364.       return(ERR_DISPLAY);
  365.       }
  366.    InitRastPort(&rp1);              /* initialize rastport for text output */
  367.    InitRastPort(&rp2);              /* initialize rastport */
  368.    InitRastPort(&rp3);              /* initialize rastport */
  369.    rp1.BitMap=vp2.bitmap1;          /* tell rastport to use our bitmap (page 1) */
  370.    rp2.BitMap=vp2.bitmap2;          /* tell rastport to use our bitmap (page 2) */
  371.    rp3.BitMap=vp.bitmap1;           /* tell rastport to use our bitmap (options screen) */
  372.    SetDrMd(&rp1,JAM2);              /* drawing mode */
  373.    SetDrMd(&rp2,JAM2);
  374.    SetDrMd(&rp3,JAM2);
  375.    SetAPen(&rp1,1);                 /* select pen color (white) */
  376.    SetAPen(&rp2,1);                 /* select pen color (white) */
  377.    SetAPen(&rp3,11);                /* select pen color for options screen */
  378.    font=OpenFont(&topaz8);          /* open the font we'll use (ugly ROM font) */
  379.    if (font)
  380.       {
  381.       SetFont(&rp1,font);           /* allow gfx lib to use our font with Text() */
  382.       SetFont(&rp2,font);
  383.       SetFont(&rp3,font);
  384.       }
  385.    loadpic.bitmap1=vp.bitmap2;      /* tell picture loader where to put picture */
  386.    if (gs_loadILBM(&loadpic))       /* only need to load 1 bitmap because */
  387.       {                             /* we'll put options screen on other page */
  388.       gs_remove_display(&display);  /* and copy background imagery when done. */
  389.       return(ERR_BATTLEFIELD);
  390.       }
  391.    gs_open_vb_timer();              /* open fast vertical blank counter */
  392.    load.flags=ANIMLOAD_NOCOLOR;     /* don't allocate a color table */
  393.    load.array_elements=1;           /* number of array elements desired */
  394.    load.filename="gfx/tank_gold.anim";   /* name of anim file */
  395.    if (gs_load_anim(&load))         /* load the anim object */
  396.       {
  397.       cleanup();
  398.       return(ERR_GOLDTANK);
  399.       }
  400.    tank[0]=load.anim_ptr.anim;      /* ptr to anim object */
  401.    load.filename="gfx/tank_blue.anim";   /* name of anim file */
  402.    if (gs_load_anim(&load))         /* load the anim object */
  403.       {
  404.       cleanup();
  405.       return(ERR_BLUETANK);
  406.       }
  407.    tank[1]=load.anim_ptr.anim;      /* ptr to anim object */
  408.    load.filename="gfx/pointer.anim";   /* name of anim file */
  409.    if (gs_load_anim(&load))         /* load the anim object */
  410.       {
  411.       cleanup();
  412.       return(ERR_PTR);
  413.       }
  414.    ptr=load.anim_ptr.anim;          /* ptr to anim object */
  415.    load.array_elements=PLAYERS;     /* number of array elements desired (2 bullets) */
  416.    load.filename="gfx/bullet.cplx"; /* name of anim file */
  417.    if (gs_load_anim(&load))         /* load the anim object */
  418.       {
  419.       cleanup();
  420.       return(ERR_BULLET);
  421.       }
  422.    bullet=load.anim_ptr.cplx;       /* ptr to anim object */
  423.    load.filename="gfx/explode.anim"; /* name of anim file */
  424.    if (gs_load_anim(&load))         /* load the anim object */
  425.       {
  426.       cleanup();
  427.       return(ERR_EXPLODE);
  428.       }
  429.    explode=load.anim_ptr.anim;      /* ptr to anim object */
  430.    if ((dlist=gs_get_display_list()) < 0) /* allocate a display list for game anims */
  431.       {
  432.       cleanup();
  433.       return(ERR_ANIMLIST);
  434.       }
  435.    if ((dlist2=gs_get_display_list()) < 0)
  436.       {                             /* allocate a display list for options pointer */
  437.       cleanup();
  438.       return(ERR_ANIMLIST);
  439.       }
  440.    if (get_sounds())                /* load all of our sound efx */
  441.       {
  442.       cleanup();
  443.       return(ERR_SOUNDLOAD);
  444.       }
  445.    if (gs_open_sound(1,0,0,(4096/2)))   /* open sound system, OS friendly */
  446.       {
  447.       cleanup();
  448.       return(ERR_SOUNDOPEN);
  449.       }
  450.    bm3=gs_get_bitmap(vp.depth,vp.bmwidth,vp.bmheight,0);
  451.    if (bm3)              /* try to get "spare" bitmap for faster obj display */
  452.       copy_bitmap(vp.bitmap2,bm3); /* set up spare bitmap for background restore */
  453.    gs_init_anim(dlist,vp.bitmap1,vp.bitmap2,bm3);   /* tell anim system about bitmaps */
  454.    
  455.    /* dlist2 will use the same bitmap areas, but contains the animated pointer for */
  456.    /* the options screen.  We'll only call gs_draw_anims(dlist2) when the options */
  457.    /* are displayed.  This is an easy way to keep the anim objects separate, while */
  458.    /* using the same bitmaps for display. */
  459.  
  460.    gs_init_anim(dlist2,vp.bitmap1,vp.bitmap2,NULL);
  461.  
  462.    gs_set_anim_bounds(dlist,0,0,vp.width+8-1,vp.height-1);
  463.    gs_set_collision(dlist,&collision);   /* set ptr to collision handler */
  464.    gs_set_collision_bg(dlist,&collision_bg);   /* set ptr to background collision handler */
  465.    if (gs_add_anim(dlist,tank[0],0,0))
  466.       {                          /* if can't add object to display list */
  467.       cleanup();
  468.       return(ERR_ANIMADD);       /* return failure */
  469.       }
  470.    
  471.    /* The "label" area of an anim object is for user consumption.  We're gonna */
  472.    /* reassign its value so that it corresponds to an array index instead of the */
  473.    /* unique ID number it was given by CITAS.  This will make using our objects */
  474.    /* easier for this game.  The label will now contain the player number (0 or 1). */
  475.    
  476.    tank[0]->label=0;             /* reassign label value to array index */
  477.  
  478.    if (gs_add_anim(dlist,tank[1],0,0))
  479.       {                          /* if can't add object to display list */
  480.       cleanup();
  481.       return(ERR_ANIMADD);       /* return failure */
  482.       }
  483.    tank[1]->label=1;             /* reassign label value to array index */
  484.    for (cnt=0; cnt < PLAYERS; cnt++)
  485.       {
  486.       bullet[cnt].label=cnt;     /* re-assign label to correspond to array value */
  487.       if (gs_add_anim_cplx(dlist,&bullet[cnt],0,0,0,bullet[0].list->prio))
  488.          {
  489.          cleanup();
  490.          return(ERR_ANIMADD);
  491.          }
  492.       if (gs_add_anim(dlist,&explode[cnt],0,0))
  493.          {
  494.          cleanup();
  495.          return(ERR_ANIMADD);
  496.          }
  497.       }
  498.  
  499.    /* the following function call can't fail since the object doesn't require */
  500.    /* a background save area (it uses the "erase" display method). */
  501.    
  502.    gs_add_anim(dlist2,ptr,0,0);  /* add pointer to 2nd display list (for options) */
  503.    
  504.    if (intui_happy())            /* open screen & window to trap mouse events */
  505.       {
  506.       cleanup();
  507.       return(ERR_INTUITION);
  508.       }
  509.    gs_show_display(&display,1);  /* show the display */
  510.    return(0);                    /* all went well */
  511. }
  512.  
  513. /***************************************************************************/
  514. /* load all the sound samples.  GameSmith sound handling is very easy.     */
  515.  
  516. int get_sounds()
  517.  
  518. {
  519.    int err;
  520.    
  521.    shoot.data=NULL;            /* no sounds loaded yet */
  522.    explode_hit.data=NULL;
  523.    explode_miss.data=NULL;
  524.    bounce1.data=NULL;
  525.    bounce2.data=NULL;
  526.    move.data=NULL;
  527.    shoot.flags=SND_FAST;      /* load sound samples to Fast RAM if available */
  528.    explode_hit.flags=SND_FAST;
  529.    explode_miss.flags=SND_FAST;
  530.    bounce1.flags=SND_FAST;
  531.    bounce2.flags=SND_FAST;
  532.    move.flags=SND_FAST;
  533.    if (err=gs_load_iff_sound(&shoot,0L,"snd/shot"))
  534.       return(err);
  535.    if (err=gs_load_iff_sound(&explode_hit,0L,"snd/explosion1"))
  536.       return(err);
  537.    if (err=gs_load_iff_sound(&explode_miss,0L,"snd/explosion2"))
  538.       return(err);
  539.    if (err=gs_load_iff_sound(&bounce1,0L,"snd/click"))
  540.       return(err);
  541.    if (err=gs_load_iff_sound(&bounce2,0L,"snd/tick"))
  542.       return(err);
  543.    if (err=gs_load_iff_sound(&move,0L,"snd/tank_roll"))
  544.       return(err);
  545.    return(0);
  546. }
  547.  
  548. /***************************************************************************/
  549.  
  550. int intui_happy()
  551.  
  552. {
  553.    if (!(screen=(struct Screen *)OpenScreen((struct NewScreen *)&dummy_screen)))
  554.       {                 /* open our stubby 1 bitplane little screen */
  555.       return(-1);
  556.       }
  557.    dummy_window.Screen = screen;
  558.    if (!(window=(struct Window *)OpenWindow(&dummy_window)))
  559.       {
  560.       CloseScreen(screen);
  561.       return(-1);
  562.       }
  563.    return(0);
  564. }
  565.  
  566. /***************************************************************************/
  567. /* this function is called in the event of a setup error.                  */
  568.  
  569. void error_display(err)
  570. int err;
  571.  
  572. {
  573.    switch (err)
  574.       {
  575.       case ERR_DISPLAY:
  576.          printf("\nError opening GameSmith display\n\n");
  577.          break;
  578.       case ERR_BATTLEFIELD:
  579.          printf("\nCan't load battlefield picture\n\n");
  580.          break;
  581.       case ERR_GOLDTANK:
  582.          printf("\nCan't load gold tank anim object\n\n");
  583.          break;
  584.       case ERR_BLUETANK:
  585.          printf("\nCan't load blue tank anim object\n\n");
  586.          break;
  587.       case ERR_PTR:
  588.          printf("\nCan't load pointer anim object\n\n");
  589.          break;
  590.       case ERR_BULLET:
  591.          printf("\nCan't load bullet anim object\n\n");
  592.          break;
  593.       case ERR_EXPLODE:
  594.          printf("\nCan't load explosion anim object\n\n");
  595.          break;
  596.       case ERR_ANIMLIST:
  597.          printf("\nCan't allocate animation display list\n\n");
  598.          break;
  599.       case ERR_SOUNDLOAD:
  600.          printf("\nCan't load one or more sound samples\n\n");
  601.          break;
  602.       case ERR_SOUNDOPEN:
  603.          printf("\nCan't open/allocate GameSmith sound system\n\n");
  604.          break;
  605.       case ERR_ANIMADD:
  606.          printf("\nError adding anim object to display list\n\n");
  607.          break;
  608.       case ERR_INTUITION:
  609.          printf("\nError opening Intuition screen and/or window\n\n");
  610.          break;
  611.       default:
  612.          printf("\nUnknown Error %d\n\n",err);
  613.          break;
  614.       }
  615. }
  616.  
  617. /***************************************************************************/
  618.  
  619. int options()
  620.  
  621. {
  622.    int cnt,opt=0,status=0,done=0,stick;
  623.  
  624.    gs_restore_anim_bg(dlist);    /* restore background behind objects.  This is because */
  625.                                  /* we need to copy the bitmap (minus objects) later. */
  626.    gs_next_anim_page(dlist2);    /* single page operation */
  627.    if (page)                     /* clear current display page for option display */
  628.       {
  629.       clear_bitmap(vp.bitmap2);
  630.       rp3.BitMap=vp.bitmap2;     /* assign bitmap for RastPort drawing of options */
  631.       }
  632.    else
  633.       {
  634.       clear_bitmap(vp.bitmap1);
  635.       rp3.BitMap=vp.bitmap1;     /* assign bitmap for RastPort drawing */
  636.       }
  637.    clear_bitmap(vp2.bitmap1);    /* clear score area */
  638.    clear_bitmap(vp2.bitmap2);
  639.    gs_SetRGB(&display,1,0,0);    /* change score area background to black */
  640.    draw_options();
  641.    draw_optptr(opt);             /* draw options ptr */
  642.    while (!done)
  643.       {
  644.       _gs_draw_anims(dlist2);    /* draw pointer anim */
  645.       gs_vb_timer_reset();
  646.       while (gs_vb_time() < 5)   /* wait n vertical blank periods */
  647.          check_abort();            /* allow pause from within options screen */
  648.       _gs_anim_obj(ptr,ptr->x,ptr->y);   /* animate the pointer */
  649.       stick=gs_joystick(1);      /* poll joyport 1 */
  650.       if (stick & JOY_UP)
  651.          {
  652.          opt--;
  653.          if (opt < 0)
  654.             {
  655.             opt=OPTIONS-1;
  656.             if (game_in_progress)
  657.                opt++;
  658.             }
  659.          draw_optptr(opt);
  660.          _gs_start_sound(sound[0][BOUNCE],channel[0][BOUNCE]);
  661.          }
  662.       else if (stick & JOY_DOWN)
  663.          {
  664.          opt++;
  665.          if (opt >= OPTIONS)
  666.             {
  667.             if (opt > OPTIONS)
  668.                opt=0;
  669.             else if (!game_in_progress)
  670.                opt=0;
  671.             }
  672.          draw_optptr(opt);
  673.          _gs_start_sound(sound[0][BOUNCE],channel[0][BOUNCE]);
  674.          }
  675.       else if (stick & (JOY_RIGHT|JOY_LEFT|JOY_BUTTON1))
  676.          {
  677.          switch (opt)
  678.             {
  679.             case 0:
  680.                if ((stick & JOY_RIGHT) && (bullet_speed < MAX_SPEED))
  681.                   {
  682.                   bullet_speed++;
  683.                   draw_options();
  684.                   _gs_start_sound(sound[1][BOUNCE],channel[1][BOUNCE]);
  685.                   }
  686.                else if ((stick & JOY_LEFT) && (bullet_speed > 1))
  687.                   {
  688.                   bullet_speed--;
  689.                   draw_options();
  690.                   _gs_start_sound(sound[1][BOUNCE],channel[1][BOUNCE]);
  691.                   }
  692.                break;
  693.             case 1:
  694.                bounce^=1;            /* flip bounce status */
  695.                draw_options();      /* show change */
  696.                _gs_start_sound(sound[1][BOUNCE],channel[1][BOUNCE]);
  697.                break;
  698.             case 2:
  699.                multitask^=1;         /* flip multitasking status */
  700.                if (multitask)
  701.                   Permit();         /* let other tasks run */
  702.                else
  703.                   Forbid();         /* take over entire machine */
  704.                draw_options();      /* show change */
  705.                _gs_start_sound(sound[1][BOUNCE],channel[1][BOUNCE]);
  706.                break;
  707.             case 3:
  708.                if (stick & JOY_BUTTON1)
  709.                   {
  710.                   done=1;            /* start a new game.  Let 'er rip! */
  711.                   reset();            /* reset object positions */
  712.                   game_in_progress=1; /* flag new game started */
  713.                   }
  714.                break;
  715.             case 4:
  716.                if (stick & JOY_BUTTON1)
  717.                   done=status=1;      /* quit back to WorkBench */
  718.                break;
  719.             case 5:
  720.                if (stick & JOY_BUTTON1)
  721.                   done=1;            /* resume game */
  722.                break;
  723.             default:
  724.                break;
  725.             }
  726.          }
  727.       }
  728.    if (!status)
  729.       {
  730.       if (page)
  731.          copy_bitmap(vp.bitmap1,vp.bitmap2);
  732.       else
  733.          copy_bitmap(vp.bitmap2,vp.bitmap1);
  734.       gs_SetRGB(&display,1,0,SCORE_BG); /* change score area background to correct color */
  735.       for (cnt=0; cnt < PLAYERS; cnt++)
  736.          _gs_enable_anim(tank[cnt]);   /* show tanks */
  737.       show_scores();
  738.       for (cnt=0; cnt < 12; cnt++)   /* build bullet speed table */
  739.          {
  740.          bmove_x[cnt]=move_x[cnt]*bullet_speed;
  741.          bmove_y[cnt]=move_y[cnt]*bullet_speed;
  742.          }
  743.       gs_vb_timer_reset();
  744.       while (gs_vb_time() < 25);      /* delay a bit before starting new game */
  745.       }
  746.    gs_next_anim_page(dlist2);      /* sync back to game anims */
  747.    return(status);               /* play the game! (or quit) */
  748. }
  749.  
  750. /***************************************************************************/
  751.  
  752. void draw_options()
  753.  
  754. {
  755.    int line=OPT_TOP;
  756.    char text[64];
  757.  
  758.    strcpy(text,"Esc for options, 'P' to pause");
  759.    Move(&rp3,50,line-OPT_SPACING);
  760.    Text(&rp3,text,strlen(text));
  761.    sprintf(text,"BULLET SPEED : %d",bullet_speed);
  762.    Move(&rp3,100,line);
  763.    Text(&rp3,text,strlen(text));
  764.    if (bounce)
  765.       strcpy(text,"BULLET BOUNCE: YES");
  766.    else
  767.       strcpy(text,"BULLET BOUNCE: NO ");
  768.    line+=OPT_SPACING;            /* space between option lines */
  769.    Move(&rp3,100,line);
  770.    Text(&rp3,text,strlen(text));
  771.    if (multitask)
  772.       strcpy(text,"MULTITASKING: YES");
  773.    else
  774.       strcpy(text,"MULTITASKING: NO ");
  775.    line+=OPT_SPACING;            /* space between option lines */
  776.    Move(&rp3,100,line);
  777.    Text(&rp3,text,strlen(text));
  778.    strcpy(text,"NEW GAME");
  779.    line+=OPT_SPACING;            /* space between option lines */
  780.    Move(&rp3,100,line);
  781.    Text(&rp3,text,strlen(text));
  782.    strcpy(text,"QUIT");
  783.    line+=OPT_SPACING;            /* space between option lines */
  784.    Move(&rp3,100,line);
  785.    Text(&rp3,text,strlen(text));
  786.    if (game_in_progress)
  787.       {
  788.       strcpy(text,"RESUME GAME");
  789.       line+=OPT_SPACING;            /* space between option lines */
  790.       Move(&rp3,100,line);
  791.       Text(&rp3,text,strlen(text));
  792.       }
  793. }
  794.  
  795. /***************************************************************************/
  796.  
  797. void draw_optptr(opt)
  798. int opt;
  799.  
  800. {
  801.    _gs_move_anim(ptr,70,OPT_TOP+(opt*OPT_SPACING)-ptr->height+3);
  802. }
  803.  
  804. /***************************************************************************/
  805. /* reset all variables, place anims, & get everything ready for battle.    */
  806.  
  807. void reset()
  808.  
  809. {
  810.    int cnt;
  811.  
  812.    for (cnt=0; cnt < PLAYERS; cnt++)
  813.       {
  814.       score[cnt]=0;        /* no scores yet */
  815.       flicker[cnt]=0;      /* not invulnerable */
  816.       boom[cnt]=0;         /* no ongoing explosions */
  817.       blowup[cnt]=NULL;    /* no bullets even on screen */
  818.       gotcha[cnt]=0;       /* nobody has been hit yet */
  819.       fire[cnt]=0;         /* no bullets have been fired */
  820.       turn[cnt]=0;         /* no turn delay yet */
  821.       bump[cnt][0]=bump[cnt][1]=0;   /* not bumping into anything yet */
  822.       _gs_clear_cplx(&bullet[cnt]);  /* make sure bullets aren't displayed */
  823.       _gs_clear_anim(&explode[cnt]); /* make sure explosions are invisible */
  824.       _gs_clear_anim(tank[cnt]);     /* clear tank from screen */
  825.       _gs_clear_anim_flicker(tank[cnt]);   /* make sure not flickering */
  826.       }                     /* randomly place both tanks */
  827.    _gs_move_anim(tank[0],_gs_random(vp.width/4),_gs_random(vp.height/4));
  828.    _gs_set_anim_cell(tank[0],_gs_random(tank[0]->count));  /* random direction for tank */
  829.    _gs_move_anim(tank[1],vp.width-_gs_random(vp.width/4),
  830.       vp.height-_gs_random(vp.height/4));
  831.    _gs_set_anim_cell(tank[1],_gs_random(tank[1]->count));  /* random direction for tank */
  832.    gs_draw_anims(dlist);            /* draw anims to make sure they're erased */
  833.    gs_next_anim_page(dlist);        /* tell animation system to use other bitmap next time */
  834.    gs_next_anim_page(dlist2);       /* sync options ptr to correct page */
  835.    gs_flip_display(&display,1);     /* flip to next bitmap page during next vertical blank */
  836.    page^=1;                         /* keep track of display page */
  837.    while (display.flags & GSV_FLIP);/* while page not flipped yet */
  838.    gs_draw_anims(dlist);            /* draw anims to make sure they're erased */
  839.    gs_next_anim_page(dlist);        /* tell animation system to use other bitmap next time */
  840.    gs_next_anim_page(dlist2);       /* sync options ptr to correct page */
  841.    gs_flip_display(&display,1);     /* flip to next bitmap page during next vertical blank */
  842.    page^=1;                         /* keep track of display page */
  843. }
  844.  
  845. /***************************************************************************/
  846.  
  847. void wait_winner(winner)
  848. int winner;
  849.  
  850. {
  851.    char win_text[16];
  852.  
  853.    game_in_progress=0;             /* flag game over */
  854.    clear_bitmap(vp2.bitmap1);      /* clear score area */
  855.    clear_bitmap(vp2.bitmap2);
  856.    if (winner)
  857.       strcpy(win_text,"Blue Tank WINS!");
  858.    else
  859.       strcpy(win_text,"Gold Tank WINS!");
  860.    Move(&rp1,100,12);
  861.    Text(&rp1,win_text,15);
  862.    Move(&rp2,100,12);
  863.    Text(&rp2,win_text,15);
  864.    gs_vb_timer_reset();
  865.    while (gs_vb_time() < (frame_rate*2))  /* delay 2 seconds */
  866.       {  /* delay at end (in case winner is still holding button down) */
  867. /*      winner_efx();   */         /* nice special efx for winner */
  868.       }
  869.    while (!(_gs_joystick(winner) & JOY_BUTTON1)); /* wait for winner to press button */
  870.    clear_bitmap(vp2.bitmap1);      /* clear score area */
  871.    clear_bitmap(vp2.bitmap2);
  872.    gs_vb_timer_reset();
  873.    while (gs_vb_time() < (frame_rate/2)); /* delay a bit before starting new game */
  874. }
  875.  
  876. /***************************************************************************/
  877.  
  878. void clear_bitmap(bitmap)
  879. struct BitMap *bitmap;
  880.  
  881. {
  882.    int cnt;
  883.  
  884.    for (cnt=0; cnt < bitmap->Depth; cnt++)   /* clear each plane */
  885.       {         
  886.       gs_blit_fill((unsigned short *)bitmap->Planes[cnt],
  887.          bitmap->Rows*(bitmap->BytesPerRow/2),0);
  888.       }
  889. }
  890.  
  891. /***************************************************************************/
  892.  
  893. void copy_bitmap(src,dest)
  894. struct BitMap *src,*dest;
  895.  
  896. {
  897.    int cnt;
  898.  
  899.    for (cnt=0; cnt < src->Depth; cnt++)
  900.       {
  901.       gs_blit_memcopy(src->Planes[cnt],dest->Planes[cnt],
  902.          (src->BytesPerRow/2)*src->Rows);
  903.       }
  904. }
  905.  
  906. /***************************************************************************/
  907. /*
  908.    This handles movement & animation of all objects.
  909. */
  910.  
  911. int fight()
  912.  
  913. /* move & animate everything */
  914.  
  915. {
  916.    int player,stick,status=0;
  917.  
  918.    for (player=0; player < PLAYERS; player++)
  919.       {
  920.       if (flicker[player]) /* if tank flickering after being hit */
  921.          {
  922.          flicker[player]--;
  923.          if (!flicker[player])
  924.             _gs_clear_anim_flicker(tank[player]);
  925.          }
  926.       if (boom[player])    /* if bullet exploding */
  927.          {
  928.           if ((explode[player].cell+1) == explode[player].count)
  929.             {
  930.             _gs_clear_anim(&explode[player]);
  931.             _gs_set_anim_cell(&explode[player],0);
  932.             boom[player]=0;
  933.             }
  934.          else
  935.             _gs_anim_obj(&explode[player],explode[player].x,explode[player].y);
  936.          }
  937.       if (blowup[player])  /* if bullet should start exploding */
  938.          {
  939.          fire[player]=0;
  940.          boom[player]=1;            /* flag explosion anim */
  941.          _gs_move_anim(&explode[player],blowup[player]->anim->x+
  942.             blowup[player]->anim->list->x_off - explode[player].width,
  943.             blowup[player]->anim->y+blowup[player]->anim->list->y_off -
  944.             (explode[player].height/2));
  945.          _gs_enable_anim(&explode[player]); /* show explosion */
  946.          _gs_clear_cplx(blowup[player]);    /* make bullet invisible again */
  947.          blowup[player]=NULL;
  948.          }
  949.       if (gotcha[player])  /* if a player was hit */
  950.          {
  951.          _gs_set_anim_flicker(tank[player]);
  952.          gotcha[player]=0;
  953.          flicker[player]=FLICKER_DELAY;
  954.          status = show_scores();      /* update scores, check end of game */
  955.          }
  956.       if (fire[player])    /* if player has a shot in the air */
  957.          {
  958.          if (bullet[player].anim->flags & (ANIM_BOUNDS_X1|ANIM_BOUNDS_X2|
  959.             ANIM_BOUNDS_Y1|ANIM_BOUNDS_Y2))   /* if bullet hit edge of bitmap */
  960.             {
  961.             if (bounce) /* if bouncing bullets option */
  962.                {
  963.                if (bullet[player].anim->flags & (ANIM_BOUNDS_X1|ANIM_BOUNDS_X2))
  964.                   bounce_em(&bullet[player],bullet[player].label,1);   /* hit vertical wall */
  965.                else
  966.                   bounce_em(&bullet[player],bullet[player].label,0);   /* hit horizontal wall */
  967.                _gs_anim_cplx(&bullet[player],bullet[player].anim->x+bmove[player][0],
  968.                   bullet[player].anim->y+bmove[player][1]);
  969.                }
  970.             else        /* else blow up bullet */
  971.                {
  972.                fire[player]=0;
  973.                boom[player]=1;         /* flag explosion anim */
  974.                _gs_move_anim(&explode[player],bullet[player].anim->x+
  975.                   bullet[player].anim->list->x_off -
  976.                   explode[player].width,bullet[player].anim->y+
  977.                   bullet[player].anim->list->y_off -
  978.                   (explode[player].height/2));
  979.                _gs_enable_anim(&explode[player]);   /* show explosion */
  980.                _gs_clear_cplx(&bullet[player]);   /* make bullet invisible again */
  981.                _gs_start_sound(sound[player][MISS],channel[player][MISS]);
  982.                }
  983.             }
  984.          else                        /* else move & animate bullet */
  985.             _gs_anim_cplx(&bullet[player],bullet[player].anim->x+bmove[player][0],
  986.                bullet[player].anim->y+bmove[player][1]);
  987.          }
  988.       if (turn[player])    /* don't turn too fast, else uncontrollable */
  989.          turn[player]--;
  990.       if (bdelay[player])  /* counter lets player shoot again before bullet exploded */
  991.          bdelay[player]--;
  992.       if (stick=_gs_joystick(player))  /* check if player leaning on 'da stick */
  993.          {
  994.          if ((stick & JOY_LEFT) && (!turn[player]))
  995.             {
  996.             if (tank[player]->cell)
  997.                _gs_set_anim_cell(tank[player],tank[player]->cell-1);   /* turn left */
  998.             else
  999.                _gs_set_anim_cell(tank[player],tank[player]->count-1);  /* turn left */
  1000.             if (!(_gs_sound_check() & channel[player][MOVE]))
  1001.                _gs_start_sound(sound[player][MOVE],channel[player][MOVE]);
  1002.             turn[player]=TURN_RATE;
  1003.             }
  1004.          else if ((stick & JOY_RIGHT) && (!turn[player]))
  1005.             {
  1006.             if (tank[player]->cell < (tank[player]->count-1))
  1007.                _gs_set_anim_cell(tank[player],tank[player]->cell+1);   /* turn right */
  1008.             else
  1009.                _gs_set_anim_cell(tank[player],0);                      /* turn right */
  1010.             if (!(_gs_sound_check() & channel[player][MOVE]))
  1011.                _gs_start_sound(sound[player][MOVE],channel[player][MOVE]);
  1012.             turn[player]=TURN_RATE;
  1013.             }
  1014.          if ((stick & JOY_UP)&&(!bump[player][0])) /* move forward in current direction */
  1015.             {
  1016.             tank[player]->x+=move_x[tank[player]->cell];
  1017.             tank[player]->y+=move_y[tank[player]->cell];
  1018.             if (!(_gs_sound_check() & channel[player][MOVE]))
  1019.                _gs_start_sound(sound[player][MOVE],channel[player][MOVE]);
  1020.             }
  1021.          else if ((stick & JOY_DOWN)&&(!bump[player][1])) /* back up */
  1022.             {
  1023.             tank[player]->x-=move_x[tank[player]->cell];
  1024.             tank[player]->y-=move_y[tank[player]->cell];
  1025.             if (!(_gs_sound_check() & channel[player][MOVE]))
  1026.                _gs_start_sound(sound[player][MOVE],channel[player][MOVE]);
  1027.             }
  1028.          if ((stick & JOY_BUTTON1) && (!bdelay[player]))
  1029.             {                        /* if fire button pressed */
  1030.             fire[player]=1;
  1031.             _gs_enable_cplx(&bullet[player]);   /* make bullet visible */
  1032.             _gs_set_cplx_seq(&bullet[player],tank[player]->cell,
  1033.                tank[player]->x,tank[player]->y); /* set proper anim & placement */
  1034.                                     /* remember bullet movement */
  1035.             bmove[player][0]=move_x[tank[player]->cell]*bullet_speed;
  1036.             bmove[player][1]=move_y[tank[player]->cell]*bullet_speed;
  1037.             bdirect[player]=tank[player]->cell;   /* remember bullet direction */
  1038.             _gs_start_sound(sound[player][SHOOT],channel[player][SHOOT]);
  1039.             bdelay[player]=RELOAD_DELAY;
  1040.             blowup[player]=NULL;
  1041.             }
  1042.          bump[player][0]=bump[player][1]=0;   /* clear bump indicators */
  1043.          }
  1044.       }
  1045.    if ((display.flags & GSV_FLIP) && multitask)
  1046.       WaitTOF();                     /* give up CPU if multitasking */
  1047.    while (display.flags & GSV_FLIP); /* while page not flipped yet */
  1048.    _gs_draw_anims(dlist);            /* draw them anim objects! */
  1049.    gs_flip_display(&display,1);      /* switch to other display, sync */
  1050.    _gs_next_anim_page(dlist);         /* tell anim sys to use other bitmap */
  1051.    _gs_next_anim_page(dlist2);      /* sync options ptr to correct page */
  1052.    page^=1;                           /* keep track of display page */
  1053.    return(status);
  1054. }
  1055.  
  1056. /***************************************************************************/
  1057.  
  1058. int show_scores()
  1059.  
  1060. {
  1061.    char temp[40];
  1062.  
  1063.    sprintf(temp,"Gold Tank: %d ",score[0]);
  1064.    Move(&rp1,0,12);
  1065.    Text(&rp1,temp,13);
  1066.    Move(&rp2,0,12);
  1067.    Text(&rp2,temp,13);
  1068.    sprintf(temp,"Blue Tank: %d ",score[1]);
  1069.    Move(&rp1,216,12);
  1070.    Text(&rp1,temp,13);
  1071.    Move(&rp2,216,12);
  1072.    Text(&rp2,temp,13);
  1073.    if ((score[0] >= GAME_SCORE) || (score[1] >= GAME_SCORE))
  1074.       {
  1075.       if (score[0] > (score[1]+1))
  1076.          return(1);                     /* return player number + 1 */
  1077.       else if (score[1] > (score[0]+1))
  1078.          return(2);
  1079.       }
  1080.    return(0);
  1081. }
  1082.  
  1083. /***************************************************************************/
  1084.  
  1085. __stdargs void collision(anim1,anim2,coll1,coll2)
  1086. struct anim_struct *anim1;
  1087. struct anim_struct *anim2;
  1088. struct collision_struct *coll1;
  1089. struct collision_struct *coll2;
  1090.  
  1091. /*
  1092.  
  1093. This is the collision handler which gets called when objects bump into each
  1094. other (bullet to bullet, or bullet to tank).
  1095.  
  1096. */
  1097.  
  1098. {
  1099.    if (coll1->type == TANK_BATTLE_TANK)   /* if object 1 is a tank */
  1100.       {
  1101.       if (!flicker[anim1->label])
  1102.          {
  1103.          gotcha[anim1->label]=1;   /* flag tank as hit */
  1104.          if (anim1->label != anim2->cplx->label)   /* if someone else shot it */
  1105.             score[anim2->cplx->label]++;           /* add one to opponent's score */
  1106.          else if (score[anim1->label])             /* else if shot himself */
  1107.             score[anim1->label]--;                 /* decrease his own score! */
  1108.          blowup[anim2->cplx->label]=anim2->cplx;   /* remove appropriate bullet */
  1109.          _gs_start_sound(sound[anim1->label][HIT],channel[anim1->label][HIT]);
  1110.          }
  1111.       }
  1112.    else if (coll2->type == TANK_BATTLE_TANK) /* if object 2 is a tank */
  1113.       {
  1114.       if (!flicker[anim2->label])
  1115.          {
  1116.          gotcha[anim2->label]=1;   /* flag tank as hit */
  1117.          if (anim2->label != anim1->cplx->label)   /* if someone else shot it */
  1118.             score[anim1->cplx->label]++;           /* add one to opponent's score */
  1119.          else if (score[anim2->label])             /* else if shot himself */
  1120.             score[anim2->label]--;                 /* decrease his own score! */
  1121.          blowup[anim1->cplx->label]=anim1->cplx;   /* remove appropriate bullet */
  1122.          _gs_start_sound(sound[anim2->label][HIT],channel[anim2->label][HIT]);
  1123.          }
  1124.       }
  1125.    else      /* else bullet to bullet impact, remove both bullets */
  1126.       {
  1127.       blowup[anim1->cplx->label]=anim1->cplx;
  1128.       blowup[anim2->cplx->label]=anim2->cplx;
  1129.       _gs_start_sound(sound[anim1->cplx->label][MISS],channel[anim1->cplx->label][MISS]);
  1130.       _gs_start_sound(sound[anim2->cplx->label][MISS],channel[anim2->cplx->label][MISS]);
  1131.       }
  1132. }
  1133.  
  1134. /***************************************************************************/
  1135.  
  1136. __stdargs void collision_bg(anim,coll,color)
  1137. struct anim_struct *anim;
  1138. struct coll_bg_struct *coll;
  1139. int color;
  1140.  
  1141. /*
  1142.  
  1143. This is the collision handler which gets called when objects collide with
  1144. certain background colors (walls & steel plates).
  1145.  
  1146. */
  1147.  
  1148. {
  1149.    if (anim->img->collision->type == TANK_BATTLE_TANK)
  1150.       {
  1151.       if ((color == 16) || (color == 29) || (color == 28))
  1152.          {                               /* if tank to background collision */
  1153.          if (coll->area < 3)
  1154.             bump[anim->label][0]=1;      /* front is blocked */
  1155.          else
  1156.             bump[anim->label][1]=1;      /* rear is blocked */
  1157.          }
  1158.       }
  1159.    else if (color == 16)
  1160.       {
  1161.       blowup[anim->cplx->label]=anim->cplx;
  1162.       _gs_start_sound(sound[anim->cplx->label][MISS],channel[anim->cplx->label][MISS]);
  1163.       }
  1164.    else if ((color == 29) || (color == 28))
  1165.       {
  1166.       if (!bounce)
  1167.          {
  1168.          blowup[anim->cplx->label]=anim->cplx;
  1169.          _gs_start_sound(sound[anim->cplx->label][MISS],channel[anim->cplx->label][MISS]);
  1170.          }
  1171.       else if (color == 28)              /* vertical wall */
  1172.          bounce_em(anim->cplx,anim->cplx->label,1);
  1173.       else                               /* horizontal wall */
  1174.          bounce_em(anim->cplx,anim->cplx->label,0);
  1175.       }
  1176. }
  1177.  
  1178. /***************************************************************************/
  1179.  
  1180. void bounce_em(cplx,index,dir)
  1181. struct anim_cplx *cplx;
  1182. int index,dir;
  1183.  
  1184. {
  1185.    int snd=BOUNCE;
  1186.  
  1187.    switch (bdirect[index])
  1188.       {
  1189.       case 0:                  /* up */
  1190.          blowup[index]=cplx;
  1191.          snd=MISS;
  1192.          break;
  1193.       case 1:                  /* 30 degrees */
  1194.          if (dir)
  1195.             {
  1196.             bdirect[index]=11;
  1197.             bmove[index][0]=bmove_x[11];
  1198.             bmove[index][1]=bmove_y[11];
  1199.             }
  1200.          else
  1201.             {
  1202.             bdirect[index]=5;
  1203.             bmove[index][0]=bmove_x[5];
  1204.             bmove[index][1]=bmove_y[5];
  1205.             }
  1206.          break;
  1207.       case 2:                  /* 60 degrees */
  1208.          if (dir)
  1209.             {
  1210.             bdirect[index]=10;
  1211.             bmove[index][0]=bmove_x[10];
  1212.             bmove[index][1]=bmove_y[10];
  1213.             }
  1214.          else
  1215.             {
  1216.             bdirect[index]=4;
  1217.             bmove[index][0]=bmove_x[4];
  1218.             bmove[index][1]=bmove_y[4];
  1219.             }
  1220.          break;
  1221.       case 3:                  /* right */
  1222.          blowup[index]=cplx;
  1223.          snd=MISS;
  1224.          break;
  1225.       case 4:                  /* 120 degrees */
  1226.          if (dir)
  1227.             {
  1228.             bdirect[index]=8;
  1229.             bmove[index][0]=bmove_x[8];
  1230.             bmove[index][1]=bmove_y[8];
  1231.             }
  1232.          else
  1233.             {
  1234.             bdirect[index]=2;
  1235.             bmove[index][0]=bmove_x[2];
  1236.             bmove[index][1]=bmove_y[2];
  1237.             }
  1238.          break;
  1239.       case 5:                  /* 150 degrees */
  1240.          if (dir)
  1241.             {
  1242.             bdirect[index]=7;
  1243.             bmove[index][0]=bmove_x[7];
  1244.             bmove[index][1]=bmove_y[7];
  1245.             }
  1246.          else
  1247.             {
  1248.             bdirect[index]=1;
  1249.             bmove[index][0]=bmove_x[1];
  1250.             bmove[index][1]=bmove_y[1];
  1251.             }
  1252.          break;
  1253.       case 6:                  /* down */
  1254.          blowup[index]=cplx;
  1255.          snd=MISS;
  1256.          break;
  1257.       case 7:                  /* 210 degrees */
  1258.          if (dir)
  1259.             {
  1260.             bdirect[index]=5;
  1261.             bmove[index][0]=bmove_x[5];
  1262.             bmove[index][1]=bmove_y[5];
  1263.             }
  1264.          else
  1265.             {
  1266.             bdirect[index]=11;
  1267.             bmove[index][0]=bmove_x[11];
  1268.             bmove[index][1]=bmove_y[11];
  1269.             }
  1270.          break;
  1271.       case 8:                  /* 240 degrees */
  1272.          if (dir)
  1273.             {
  1274.             bdirect[index]=4;
  1275.             bmove[index][0]=bmove_x[4];
  1276.             bmove[index][1]=bmove_y[4];
  1277.             }
  1278.          else
  1279.             {
  1280.             bdirect[index]=10;
  1281.             bmove[index][0]=bmove_x[10];
  1282.             bmove[index][1]=bmove_y[10];
  1283.             }
  1284.          break;
  1285.       case 9:                  /* left */
  1286.          blowup[index]=cplx;
  1287.          snd=MISS;
  1288.          break;
  1289.       case 10:                  /* 300 degrees */
  1290.          if (dir)
  1291.             {
  1292.             bdirect[index]=2;
  1293.             bmove[index][0]=bmove_x[2];
  1294.             bmove[index][1]=bmove_y[2];
  1295.             }
  1296.          else
  1297.             {
  1298.             bdirect[index]=8;
  1299.             bmove[index][0]=bmove_x[8];
  1300.             bmove[index][1]=bmove_y[8];
  1301.             }
  1302.          break;
  1303.       case 11:                  /* 330 degrees */
  1304.          if (dir)
  1305.             {
  1306.             bdirect[index]=1;
  1307.             bmove[index][0]=bmove_x[1];
  1308.             bmove[index][1]=bmove_y[1];
  1309.             }
  1310.          else
  1311.             {
  1312.             bdirect[index]=7;
  1313.             bmove[index][0]=bmove_x[7];
  1314.             bmove[index][1]=bmove_y[7];
  1315.             }
  1316.          break;
  1317.       }
  1318.    _gs_start_sound(sound[index][snd],channel[index][snd]);
  1319. }
  1320.  
  1321. /***************************************************************************/
  1322. /* BAD PRACTICE ALERT! ptr to hardware keyboard reg used here!!            */
  1323. /* This is used because it's the fastest way to read keyboard values.      */
  1324.  
  1325. int check_abort()
  1326.  
  1327. {
  1328.    unsigned char key;
  1329.  
  1330.    key=*keybrd;
  1331.    if (key == 0x75)                  /* if user hits Esc key */
  1332.       return(1);                     /* abort positive */
  1333.    else if (key == 205)
  1334.       pause_game();                  /* pause game if user hit 'p' */
  1335.    return(0);
  1336. }
  1337.  
  1338. /***************************************************************************/
  1339.  
  1340. void pause_game()
  1341.  
  1342. {
  1343.    int done=0;
  1344.    struct IntuiMessage *msg;
  1345.    struct Window *pwindow;
  1346.  
  1347.    if (!multitask)
  1348.       Permit();
  1349.    ScreenToBack(screen);
  1350.    gs_old_display(&display);      /* show intuition display */
  1351.    if (!(pwindow=(struct Window *)OpenWindow(&pause_window)))
  1352.       {
  1353.       return;
  1354.       }
  1355.    while (!done)
  1356.       {
  1357.       WaitPort(pwindow->UserPort);
  1358.       while (msg=(struct IntuiMessage *)GetMsg(pwindow->UserPort))
  1359.          {
  1360.          if (msg->Class == CLOSEWINDOW)
  1361.             done=1;
  1362.          ReplyMsg((struct Message *)msg);
  1363.          }
  1364.       }
  1365.    CloseWindow(pwindow);
  1366.    ScreenToFront(screen);
  1367.    ActivateWindow(window);        /* reactivate tank window to trap keyboard hits */
  1368.    gs_show_display(&display,1);   /* show our display again */
  1369.    if (!multitask)
  1370.       Forbid();
  1371. }
  1372.  
  1373. /***************************************************************************/
  1374.  
  1375. void cleanup()
  1376.  
  1377. /* release all resources and memory */
  1378.  
  1379. {
  1380.    if (!multitask)
  1381.       Permit();               /* multitasking on while we clean up (no need for it off) */
  1382.    gs_close_vb_timer();
  1383.    gs_close_sound();          /* shut down sound system */
  1384.    if (shoot.data)
  1385.       gs_free_sound(&shoot);
  1386.    if (explode_hit.data)
  1387.       gs_free_sound(&explode_hit);
  1388.    if (explode_miss.data)
  1389.       gs_free_sound(&explode_miss);
  1390.    if (bounce1.data)
  1391.       gs_free_sound(&bounce1);
  1392.    if (bounce2.data)
  1393.       gs_free_sound(&bounce2);
  1394.    if (move.data)
  1395.       gs_free_sound(&move);
  1396.    if (dlist > -1)
  1397.       gs_free_display_list(dlist);
  1398.    if (dlist2 > -1)
  1399.       gs_free_display_list(dlist2);
  1400.    if (tank[0])
  1401.       gs_free_anim(tank[0],1);
  1402.    if (tank[1])
  1403.       gs_free_anim(tank[1],1);
  1404.    if (ptr)
  1405.       gs_free_anim(ptr,1);
  1406.    if (bullet)
  1407.       gs_free_cplx(bullet,PLAYERS);
  1408.    if (explode)
  1409.       gs_free_anim(explode,PLAYERS);
  1410.    if (bm3)
  1411.       gs_free_bitmap(bm3);
  1412.    gs_remove_display(&display);
  1413.    WaitTOF();
  1414.    WaitTOF();                 /* give Intuition time to process Esc chars */
  1415.    if (window)
  1416.       CloseWindow(window);
  1417.    if (screen)
  1418.       CloseScreen(screen);
  1419.    if (font)
  1420.       CloseFont(font);
  1421. }
  1422.